home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / y2l.lha / y2l / Tables.c < prev    next >
C/C++ Source or Header  |  1992-08-20  |  11KB  |  573 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include "Memory.h"
  4. #include "StringMem.h"
  5. #include "Tables.h"
  6.  
  7. /* types for nodes of linked lists */
  8. typedef struct tName {
  9.         tStringRef name;
  10.         tStringRef alias;
  11.         struct tName *cdr;
  12.            };
  13.  
  14. typedef struct tToken {
  15.         tStringRef name;
  16.         int value;
  17.         struct tToken *cdr;
  18.            };
  19.  
  20. typedef struct tType {
  21.         tStringRef name;
  22.         tStringRef type;
  23.         struct tType *cdr;
  24.            };
  25.  
  26. typedef struct tRule {
  27.         int tag; /* 0 = text, 1 = rule */
  28.         union {
  29.             struct tCell * text;
  30.             struct tElmt * rule;
  31.               } car;
  32.         struct tRule *cdr;
  33.            };
  34.  
  35. /* heads of linked lists */
  36. struct tName * name_list = 0;
  37. struct tToken * token_list = 0;
  38.  
  39. struct tType * type_list = 0;
  40. struct tCell * oper_list = 0;
  41. struct tCell * global_list = 0;
  42. struct tCell * action_list;
  43.  
  44. tStringRef start_symbol = 0;
  45.  
  46. struct tElmt * rule_elmts_list;
  47. struct tCell * text_list = 0;
  48. struct tRule * rule_list = 0;
  49.  
  50. int token_val;
  51. int type = 0;
  52. int generate_actions = 1;
  53.  
  54. bool MyEqual (r, s)
  55. tStringRef r;
  56. tString s;
  57. {
  58.   return LengthSt (r) == strlen (s) && IsEqualSt (r, s);
  59. }
  60.  
  61. void print_symbol (r)
  62. tStringRef r;
  63. {
  64.   register struct tName * p;
  65.   char v[256];
  66.  
  67.   StGetString (r, v);
  68.   if (v[0] == '\'') {
  69.     (void) printf ("%s", v);
  70.     return;
  71.   }
  72.   for (p = name_list; p; p = p->cdr)
  73.     if (MyEqual (p->name, v)) {
  74.       WriteString (stdout, p->alias);
  75.       return;
  76.     }
  77.   (void) printf ("%s", v);
  78. }
  79.  
  80. /* check if name is already in name_list */
  81. int unique_name (v)
  82. char * v;
  83. {
  84.   register struct tName * p;
  85.   for (p = name_list; p; p = p->cdr)
  86.     if (p->alias && MyEqual (p->alias, v)) return 0;
  87.   return 1;
  88. }
  89.  
  90. /* if name not yet in list, append it */
  91. void put_name (name)
  92. tStringRef name;
  93. {
  94.   register struct tName * p;
  95.   char s[256];
  96.  
  97.   for (p = name_list; p; p = p->cdr) {
  98.     StGetString (name, s);
  99.     if (MyEqual (p->name, s)) return;
  100.   }
  101.   p = (struct tName *) Alloc (sizeof (struct tName));
  102.   p->name  = name;
  103.   p->alias = 0;
  104.   p->cdr   = name_list;
  105.   name_list = p;
  106. }
  107.  
  108. /* transform every ident with dots */
  109. void process_names ()
  110. {
  111.   register struct tName * p;
  112.   register int i;
  113.   int dotflag;
  114.   char s[256];
  115.   char v[256];
  116.  
  117.   for (p = name_list; p; p= p->cdr) {
  118.     StGetString (p->name, s);
  119.     if (s[0] != '\'') {
  120.       dotflag = 0;
  121.       for (i = 0; s[i]; i++) 
  122.         if (s[i] == '.') {
  123.         dotflag = 1;
  124.       s[i] = '_';
  125.         }
  126.       if (dotflag) {
  127.         i = 0;
  128.         do {
  129.       i++;
  130.       (void) sprintf (v, "%s_%d", s, i);
  131.         } while (! unique_name (v));
  132.         p->alias = PutString (v, strlen (v));
  133.       } else
  134.         p->alias = p->name;
  135.     } else
  136.       p->alias = p->name;
  137.   }
  138. }
  139.  
  140. /* if token not yet in list, append it */
  141. void put_token (name, value)
  142. tStringRef name;
  143. int    value;
  144. {
  145.   register struct tToken * p;
  146.   char s[256];
  147.  
  148.   for (p = token_list; p; p = p->cdr) {
  149.     StGetString (name, s);
  150.     if (MyEqual (p->name, s)) return;
  151.   }
  152.   p = (struct tToken *) Alloc (sizeof (struct tToken));
  153.   p->name  = name;
  154.   p->value = value;
  155.   p->cdr   = token_list;
  156.   token_list = p;
  157. }
  158.  
  159. /* print the TOKEN section */
  160. void aux_print_tokens (p)
  161. struct tToken * p;
  162. {
  163.   register int i, v;
  164.   char s[256];
  165.  
  166.   if (p) {
  167.     aux_print_tokens (p->cdr);
  168.     (void) printf ("\t");
  169.     print_symbol (p->name);
  170.     if (p->value) {
  171.       v = p->value;
  172.     } else {
  173.       StGetString (p->name, s);
  174.       if (s[0] == '\'') {
  175.     if (s[1] == '\\') {
  176.       switch (s[2]) {
  177.         case 'b' : v = 8; break;
  178.         case 't' : v = 9; break;
  179.         case 'n' : v = 10; break;
  180.         case 'f' : v = 12; break;
  181.         case 'r' : v = 13; break;
  182.         default :
  183.           if ((s[2] >= '0') && (s[2] <= '7')) {
  184.         v = 0;
  185.         for (i = 2; s[i] != '\''; i++)
  186.           v = 8 * v + s[i] - '0';
  187.           } else
  188.         v = (int) s[2];
  189.           break;
  190.       }
  191.     } else
  192.       if ((s[1] == '\'') && (s[2] == '\'') && (s[4] =='\0')) {
  193.         v = (int) '\'';
  194.       } else
  195.         if (s[3]) {
  196.           v = token_val++;
  197.         } else
  198.           v = (int) s[1];
  199.       } else
  200.     v = token_val++;
  201.     }
  202.     if (v)
  203.       (void) printf ("\t= %d", (int) v);
  204.     (void) printf ("\n");
  205.   }
  206. }
  207.  
  208. void print_tokens ()
  209. {
  210.   token_val = 257;
  211.   (void) printf ("\nTOKEN\n");
  212.   aux_print_tokens (token_list);
  213.   (void) printf ("\terror\n");
  214. }
  215.  
  216. /* put type of symbol to list */
  217. void put_type (name, type)
  218. tStringRef name;
  219. tStringRef type;
  220. {
  221.   struct tType *p;
  222.  
  223.   p = (struct tType *) Alloc (sizeof (struct tType));
  224.   p->name = name;
  225.   p->type = type;
  226.   p->cdr  = type_list;
  227.   type_list = p;
  228. }
  229.  
  230. /* get type of symbol */
  231. tStringRef search_type (t)
  232. tStringRef t;
  233. {
  234.   char s[256];
  235.   register struct tType * p;
  236.  
  237.   StGetString (t, s);
  238.   for (p = type_list; p; p = p->cdr)
  239.     if (MyEqual (p->name, s)) return p->type;
  240.   return 0;
  241. }
  242.  
  243. tStringRef aux_get_type (p, n)
  244. struct tElmt * p;
  245. int * n;
  246. {
  247.   if (p->tag != 2 /* lhs */) {
  248.     tStringRef t = aux_get_type (p->cdr, n);
  249.     if (p->tag == 0 /* symbol */ || p->tag == 1 /* action */ || p->tag == 4 /* last action */) -- * n;
  250.     if (! * n) {
  251.       return search_type (p->car.symbol);
  252.     } else {
  253.       return t;
  254.     }
  255.   } else {
  256.     return 0;
  257.   }
  258. }
  259.  
  260. tStringRef aux_get_type_0 ()
  261. {
  262.   register struct tElmt * p;
  263.  
  264.   for (p = rule_elmts_list; p->cdr; p = p->cdr);
  265.   return search_type (p->car.symbol);
  266. }
  267.  
  268. /* if n = 0 get type of lhs, else of n-th rhs item, 0 if no type */
  269. tStringRef get_type (n)
  270. int n;
  271. { 
  272.   if (n < 0) {
  273.     return 0;
  274.   } else if (! n) {
  275.     return aux_get_type_0 ();
  276.   } else
  277.     return aux_get_type (rule_elmts_list, &n);
  278. }
  279.  
  280. /* put operand to list */
  281. void put_oper (s)
  282. tStringRef s;
  283. {
  284.   struct tCell * p;
  285.  
  286.   p = (struct tCell *) Alloc (sizeof (struct tCell));
  287.   p->car = s;
  288.   p->cdr = oper_list;
  289.   oper_list = p;
  290. }
  291.  
  292. /* print OPER section */
  293. void aux_print_opers (p)
  294. struct tCell * p;
  295. {
  296.   if (p) {
  297.     aux_print_opers (p->cdr);
  298.     print_symbol (p->car);
  299.     (void) printf ("\t");
  300.   }
  301. }
  302.  
  303. void print_opers ()
  304. {
  305.   if (oper_list) {
  306.     (void) printf ("\nOPER");
  307.     aux_print_opers (oper_list);
  308.     (void) printf ("\n");
  309.   }
  310. }
  311.  
  312. /* put text to GLOBAL section */
  313. void put_global (v)
  314. tStringRef v;
  315. {
  316.   struct tCell * p;
  317.  
  318.   p = (struct tCell *) Alloc (sizeof (struct tCell));
  319.   p->car = v;
  320.   p->cdr = global_list;
  321.   global_list = p;
  322. }
  323.  
  324. char * YACC1 [] = {
  325.    "\n",
  326.    "# define tParsAttribute    YYSTYPE\n",
  327.    "# define yySynAttribute    yyval\n",
  328.    "# define yyTerminal    yychar\n",
  329.    "# define yyclearin\n",
  330.    "# define yyerrok\n",
  331.    "# ifndef YYMAXDEPTH\n",
  332.    "# define YYMAXDEPTH    150\n",
  333.    "# endif\n",
  334.    0
  335. };
  336.  
  337. char * YACC2 [] = {
  338.    "# ifndef YYSTYPE\n",
  339.    "# define YYSTYPE    int\n",
  340.    "# endif\n",
  341.    0
  342. };
  343.  
  344. char * YACC3 [] = {
  345.    "YYSTYPE yylval;\n",
  346.    "# define yylvalDef\n",
  347.    "# define YYERROR\n",
  348.    "# define YYACCEPT    ReleaseArray (& yyStateStack, & yyStateStackSize, sizeof (yyStateRange)); \\\\\n",
  349.    "            ReleaseArray (& yyAttributeStack, & yyAttrStackSize, sizeof (tParsAttribute)); \\\\\n",
  350.    "            return(0)\n",
  351.    "# define YYABORT    ReleaseArray (& yyStateStack, & yyStateStackSize, sizeof (yyStateRange)); \\\\\n",
  352.    "            ReleaseArray (& yyAttributeStack, & yyAttrStackSize, sizeof (tParsAttribute)); \\\\\n",
  353.    "            return(1)\n",
  354.    "# define YYBACKUP(newtoken, newvalue)    YYERROR\n",
  355.    "# define YYRECOVERING()    yyIsRepairing\n",
  356.    "\n",
  357.    0
  358. };
  359.  
  360. void yacc_globals ()
  361. {
  362.    register int i;
  363.  
  364.    for (i = 0; YACC1 [i]; i++)
  365.       put_global (PutString (YACC1 [i], strlen (YACC1 [i])));
  366.    if (! type) for (i = 0; YACC2 [i]; i++)
  367.       put_global (PutString (YACC2 [i], strlen (YACC2 [i])));
  368.    for (i = 0; YACC3 [i]; i++)
  369.       put_global (PutString (YACC3 [i], strlen (YACC3 [i])));
  370. }
  371.  
  372. /* print GLOBAL section */
  373. void aux_print_global (p)
  374. struct tCell * p;
  375. {
  376.   if (p) {
  377.     aux_print_global (p->cdr);
  378.     WriteString (stdout, p->car);
  379.   }
  380. }
  381.  
  382. void print_global ()
  383. {
  384.   if (global_list) {
  385.     (void) printf ("EXPORT {\n");
  386.     (void) printf ("# define yacc_interface\n");
  387.     (void) printf ("# define lex_interface\n");
  388.     (void) printf ("}\n\n");
  389.     (void) printf ("GLOBAL {\n");
  390.     aux_print_global (global_list);
  391.     (void) printf ("}\n");
  392.   }
  393. }
  394.  
  395. /* put text to action */
  396. void put_action (v)
  397. tStringRef v;
  398. {
  399.   struct tCell * p;
  400.  
  401.   p = (struct tCell *) Alloc (sizeof (struct tCell));
  402.   p->car = v;
  403.   p->cdr = action_list;
  404.   action_list = p;
  405. }
  406.  
  407. /* put action list to rule */
  408. void put_whole_action (v, b)
  409. struct tCell  * v;
  410. bool b;
  411. {
  412.   struct tElmt * p;
  413.  
  414.   p = (struct tElmt *) Alloc (sizeof (struct tElmt));
  415.   p->tag = b ? 4 : 1;
  416.   p->car.action = v;
  417.   p->cdr = rule_elmts_list;
  418.   rule_elmts_list = p;
  419. }
  420.  
  421. /* put lhs to rule */
  422. void put_lhs (v)
  423. tStringRef v;
  424. {
  425.   struct tElmt * p;
  426.  
  427.   p = (struct tElmt *) Alloc (sizeof (struct tElmt));
  428.   p->tag = 2;
  429.   p->car.symbol = v;
  430.   p->cdr = rule_elmts_list;
  431.   rule_elmts_list = p;
  432. }
  433.  
  434. /* put symbol to rule */
  435. void put_symbol (v)
  436. tStringRef v;
  437. {
  438.   struct tElmt * p;
  439.  
  440.   p = (struct tElmt *) Alloc (sizeof (struct tElmt));
  441.   p->tag = 0;
  442.   p->car.symbol = v;
  443.   p->cdr = rule_elmts_list;
  444.   rule_elmts_list = p;
  445. }
  446.  
  447. /* put delimiter to rule */
  448. void put_delim (v)
  449. tStringRef v;
  450. {
  451.   struct tElmt * p;
  452.  
  453.   p = (struct tElmt *) Alloc (sizeof (struct tElmt));
  454.   p->tag = 3;
  455.   p->car.symbol = v;
  456.   p->cdr = rule_elmts_list;
  457.   rule_elmts_list = p;
  458. }
  459.  
  460. /* put rule to RULE section */
  461. void put_rule (v)
  462. struct tElmt * v;
  463. {
  464.   struct tRule * p;
  465.  
  466.   p = (struct tRule *) Alloc (sizeof (struct tRule));
  467.   p->tag = 1;
  468.   p->car.rule = v;
  469.   p->cdr = rule_list;
  470.   rule_list = p;
  471. }
  472.  
  473. /* put text to list */
  474. void append_text (v)
  475. tStringRef v;
  476. {
  477.   struct tCell * p;
  478.  
  479.   p = (struct tCell *) Alloc (sizeof (struct tCell));
  480.   p->car = v;
  481.   p->cdr = text_list;
  482.   text_list = p;
  483. }
  484.  
  485. /* put text list to rule */
  486. void put_text (v)
  487. struct tCell * v;
  488. {
  489.   struct tRule * p;
  490.  
  491.   if (v) {
  492.     p = (struct tRule *) Alloc (sizeof (struct tRule));
  493.     p->tag = 0;
  494.     p->car.text = v;
  495.     p->cdr = rule_list;
  496.     rule_list = p;
  497.     text_list = 0;
  498.   }
  499. }
  500.  
  501. /* print RULE section */
  502. void print_actions (p)
  503. struct tCell * p;
  504. {
  505.   if (p) {
  506.     print_actions (p->cdr);
  507.     WriteString (stdout, p->car);
  508.   }
  509. }
  510.  
  511. void print_rule_elmts (p)
  512. struct tElmt * p;
  513. {
  514.   if (p) {
  515.     print_rule_elmts (p->cdr);
  516.     switch (p->tag) {
  517.       case 1: /* action    */
  518.     if (generate_actions) {
  519.        (void) printf ("{{");
  520.        print_actions (p->car.action);
  521.        (void) printf (" ");
  522.     }
  523.     break;
  524.       case 4: /* last action */
  525.     if (generate_actions) {
  526.        (void) printf ("{ $$ = $1; {");
  527.        print_actions (p->car.action);
  528.        (void) printf (" ");
  529.     }
  530.     break;
  531.       case 3: /* delim    */
  532.       case 0: /* symbol    */
  533.     print_symbol (p->car.symbol); (void) printf (" ");
  534.     break;
  535.       default: /* lhs    */
  536.     ;
  537.     }
  538.   }
  539. }
  540.  
  541. void print_text (p)
  542. struct tCell * p;
  543. {
  544.   if (p) {
  545.     print_text (p->cdr);
  546.     WriteString (stdout, p->car);
  547.   }
  548. }
  549.  
  550. void aux_print_rules (p)
  551. struct tRule * p;
  552. {
  553.   if (p) {
  554.     aux_print_rules (p->cdr);
  555.     if (p->tag) {
  556.       print_rule_elmts (p->car.rule);
  557.     } else
  558.       print_text (p->car.text);
  559.   }
  560. }
  561.  
  562. void print_rules ()
  563. {
  564.   (void) printf ("\nRULE\n");
  565.   if (start_symbol) {
  566.     (void) printf ("\n__START__\t: ");
  567.     print_symbol (start_symbol);
  568.     (void) printf (" .");
  569.   }
  570.   aux_print_rules (rule_list);
  571.   (void) printf ("\n");
  572. }
  573.